JavaScript Private Fields: True Class Encapsulation અને Data Hiding માં ઊંડાણપૂર્વક ડોકિયું

            
class BankAccount {
  constructor(ownerName, initialBalance) {
    this.ownerName = ownerName;
    this._balance = initialBalance; // Convention: This is 'private'
  }

  deposit(amount) {
    if (amount > 0) {
      this._balance += amount;
      console.log(`Deposited: ${amount}. New balance: ${this._balance}`);
    }
  }

  // A public getter to access the balance safely
  getBalance() {
    return this._balance;
  }
}

const myAccount = new BankAccount('John Doe', 1000);
console.log(myAccount.getBalance()); // 1000

// The problem: The convention can be ignored
myAccount._balance = -5000; // Direct manipulation is possible!
console.log(myAccount.getBalance()); // -5000 (Invalid state!)

            

              
                Copy
              
            
          

            
function createBankAccount(ownerName, initialBalance) {
  let balance = initialBalance; // This variable is private due to closure

  return {
    getOwner: () => ownerName,

    getBalance: () => balance, // Publicly exposes the balance value

    deposit: function(amount) {
      if (amount > 0) {
        balance += amount;
        console.log(`Deposited: ${amount}. New balance: ${balance}`);
      }
    },

    withdraw: function(amount) {
      if (amount > 0 && amount <= balance) {
        balance -= amount;
        console.log(`Withdrew: ${amount}. New balance: ${balance}`);
      } else {
        console.log('Insufficient funds or invalid amount.');
      }
    }
  };
}

const myAccount = createBankAccount('Jane Smith', 2000);

console.log(myAccount.getBalance()); // 2000
myAccount.deposit(500); // Deposited: 500. New balance: 2500

// Attempting to access the private variable fails
console.log(myAccount.balance); // undefined
myAccount.balance = 9999; // Creates a new, unrelated property
console.log(myAccount.getBalance()); // 2500 (The internal state is safe!)

            

              
                Copy
              
            
          

            
class BankAccount {
  // 1. Declare the private field
  #balance;

  constructor(ownerName, initialBalance) {
    this.ownerName = ownerName; // Public field
    // 2. Initialize the private field
    if (initialBalance > 0) {
      this.#balance = initialBalance;
    } else {
      throw new Error('Initial balance must be positive.');
    }
  }

  deposit(amount) {
    if (amount > 0) {
      this.#balance += amount;
      console.log(`Deposited: ${amount}.`);
    }
  }

  withdraw(amount) {
    if (amount > 0 && amount <= this.#balance) {
      this.#balance -= amount;
      console.log(`Withdrew: ${amount}.`);
    } else {
      console.error('Withdrawal failed: Invalid amount or insufficient funds.');
    }
  }

  getBalance() {
    // Public method provides controlled access to the private field
    return this.#balance;
  }
}

const myAccount = new BankAccount('Alice', 500);
myAccount.deposit(100);
console.log(myAccount.getBalance()); // 600

// Now, let's try to break it...

try {
  // This will fail. It's not a suggestion; it's a hard rule.
  console.log(myAccount.#balance);
} catch (e) {
  console.error(e); // TypeError: Cannot read private member #balance from an object whose class did not declare it
}

// This doesn't modify the private field. It creates a new, public property.
myAccount['#balance'] = 9999;
console.log(myAccount.getBalance()); // 600 (The internal state remains safe!)

            

              
                Copy
              
            
          

            
class ReportGenerator {
  #data;

  constructor(rawData) {
    this.#data = rawData;
  }

  // Private helper method for internal calculation
  #calculateTotalSales() {
    console.log('Performing complex and secret calculations...');
    return this.#data.reduce((total, item) => total + item.price * item.quantity, 0);
  }

  // Private helper for formatting
  #formatCurrency(amount) {
    // In a real-world scenario, this would use Intl.NumberFormat for global audiences
    return `$${amount.toFixed(2)}`;
  }

  // Public API method
  generateSalesReport() {
    const totalSales = this.#calculateTotalSales(); // Calls the private method
    const formattedTotal = this.#formatCurrency(totalSales); // Calls another private method

    return {
      reportDate: new Date(),
      totalSales: formattedTotal,
      itemCount: this.#data.length
    };
  }
}

const salesData = [
  { price: 10, quantity: 5 },
  { price: 25, quantity: 2 },
  { price: 5, quantity: 20 }
];

const generator = new ReportGenerator(salesData);
const report = generator.generateSalesReport();
console.log(report); // { reportDate: ..., totalSales: '$200.00', itemCount: 3 }

// Attempting to call the private method from outside fails
try {
  generator.#calculateTotalSales();
} catch (e) {
  console.error(e.name, e.message);
}

            

              
                Copy
              
            
          

            
class DatabaseConnection {
  // Private static field to count instances
  static #instanceCount = 0;

  // Private static method for logging internal events
  static #log(message) {
    console.log(`[DBConnection Internal]: ${message}`);
  }

  constructor(connectionString) {
    this.connectionString = connectionString;
    DatabaseConnection.#instanceCount++;
    DatabaseConnection.#log(`New connection created. Total: ${DatabaseConnection.#instanceCount}`);
  }

  connect() {
    console.log(`Connecting to ${this.connectionString}...`);
  }

  // Public static method to get the count
  static getInstanceCount() {
    return DatabaseConnection.#instanceCount;
  }
}

const conn1 = new DatabaseConnection('server1/db');
const conn2 = new DatabaseConnection('server2/db');

console.log(`Total connections created: ${DatabaseConnection.getInstanceCount()}`); // Total connections created: 2

// Accessing the private static members from outside is impossible
console.log(DatabaseConnection.#instanceCount); // SyntaxError
DatabaseConnection.#log('Trying to log'); // SyntaxError

            

              
                Copy
              
            
          

            
class Circle {
  #radius;

  constructor(radius) {
    this.setRadius(radius);
  }

  // Public setter with validation
  setRadius(newRadius) {
    if (typeof newRadius !== 'number' || newRadius <= 0) {
      throw new Error('Radius must be a positive number.');
    }
    this.#radius = newRadius;
  }

  get radius() {
    return this.#radius;
  }

  get area() {
    return Math.PI * this.#radius * this.#radius;
  }
}

const c = new Circle(10);
console.log(c.area); // ~314.159

c.setRadius(20); // Works as expected
console.log(c.radius); // 20

try {
  c.setRadius(-5); // Fails due to validation
} catch (e) {
  console.error(e.message); // 'Radius must be a positive number.'
}

// The internal #radius is never set to an invalid state.
console.log(c.radius); // 20

            

              
                Copy
              
            
          

            
import { hash, compare } from 'some-bcrypt-library'; // Fictional library

class User {
  #passwordHash;
  #personalIdentifier;
  #lastLoginTimestamp;

  constructor(username, password, pii) {
    this.username = username; // Public username
    this.#passwordHash = hash(password); // Store only the hash, and keep it private
    this.#personalIdentifier = pii;
    this.#lastLoginTimestamp = null;
  }

  async authenticate(passwordAttempt) {
    const isMatch = await compare(passwordAttempt, this.#passwordHash);
    if (isMatch) {
      this.#lastLoginTimestamp = Date.now();
      console.log('Authentication successful.');
      return true;
    }
    console.log('Authentication failed.');
    return false;
  }

  // A public method to get non-sensitive info
  getProfileData() {
    return {
      username: this.username,
      lastLogin: this.#lastLoginTimestamp ? new Date(this.#lastLoginTimestamp) : 'Never'
    };
  }

  // No getter for passwordHash or personalIdentifier!
}

const user = new User('globaldev', 'superS3cret!', 'ID-12345');

// The sensitive data is completely inaccessible from the outside.
console.log(user.username); // 'globaldev'
console.log(user.#passwordHash); // SyntaxError!

            

              
                Copy
              
            
          

            
class Carousel {
  #slides;
  #currentIndex;
  #containerElement;

  constructor(containerSelector, slidesData) {
    this.#containerElement = document.querySelector(containerSelector);
    this.#slides = slidesData;
    this.#currentIndex = 0;
    this.#render();
  }

  // Private method to handle all DOM updates
  #render() {
    const currentSlide = this.#slides[this.#currentIndex];
    // Logic to update the DOM to show the current slide...
    console.log(`Rendering slide ${this.#currentIndex + 1}: ${currentSlide.title}`);
  }

  // Public API methods
  next() {
    this.#currentIndex = (this.#currentIndex + 1) % this.#slides.length;
    this.#render();
  }

  prev() {
    this.#currentIndex = (this.#currentIndex - 1 + this.#slides.length) % this.#slides.length;
    this.#render();
  }

  getCurrentSlide() {
    return this.#slides[this.#currentIndex];
  }
}

const myCarousel = new Carousel('#carousel-widget', [
  { title: 'Tokyo Skyline', image: 'tokyo.jpg' },
  { title: 'Paris at Night', image: 'paris.jpg' },
  { title: 'New York Central Park', image: 'nyc.jpg' }
]);

myCarousel.next(); // Renders slide 2
myCarousel.next(); // Renders slide 3

// You cannot mess up the component's state from the outside.
// myCarousel.#currentIndex = 10; // SyntaxError! This protects the component's integrity.

            

              
                Copy
              
            
          

            
class MyClass {
  #privateField = 42;

  getPrivateFieldValue() {
    return this.#privateField; // OK
  }

  getPrivateFieldDynamically(fieldName) {
    // return this[fieldName]; // This won't work for private fields
  }
}

const instance = new MyClass();
console.log(instance.getPrivateFieldValue()); // 42
// console.log(instance['#privateField']); // undefined

            

              
                Copy
              
            
          

            
class Vehicle {
  #fuel;

  constructor(initialFuel) {
    this.#fuel = initialFuel;
  }

  drive(kilometers) {
    const fuelNeeded = kilometers / 10; // Simple consumption model
    if (this.#fuel >= fuelNeeded) {
      this.#fuel -= fuelNeeded;
      console.log(`Driven ${kilometers} km.`);
      return true;
    }
    console.log('Not enough fuel.');
    return false;
  }
}

class Car extends Vehicle {
  constructor(initialFuel) {
    super(initialFuel);
  }

  checkFuel() {
    // This will cause an error!
    // A Car cannot directly access the #fuel of a Vehicle.
    // console.log(this.#fuel);
    // To make this work, the Vehicle class would need to provide a public `getFuel()` method.
  }
}

const myCar = new Car(50);
myCar.drive(100); // Driven 100 km.
// myCar.checkFuel(); // Would throw a SyntaxError

            

              
                Copy